#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
using namespace std;
using ll=long long;
const int N=1e5+10;
const int M=3*1e5+10;

int n,m;
int f[N];
int depth[N];
int fa[N][17];
ll d1[N][17],d2[N][17];
vector<pair<int,int>> edge1[N];
struct node{
	int a,b,w;
	bool used;
	bool operator<(const struct node& p)
	{
		return w<p.w;
	}
}edge[M];
int Find(int x)
{
	if(f[x]!=x)
		f[x]=Find(f[x]);
	return f[x];
}
ll kluscal()
{
	for(int i=1;i<=n;i++)
		f[i]=i;
	sort(edge,edge+m);
	ll ret=0;
	for(int i=0;i<m;i++)
	{
		int x=Find(edge[i].a),y=Find(edge[i].b);
		int w=edge[i].w;
		if(x!=y)
		{
			f[x]=y;
			ret+=w;
			edge[i].used=true;
		}
	}
	return ret;
}
void build()
{
	for(int i=0;i<m;i++)
	{
		int x=edge[i].a,y=edge[i].b,w=edge[i].w;
		
		if(edge[i].used)
		{
			edge1[x].push_back({y,w});
			edge1[y].push_back({x,w});
		}
	}
}
void bfs()
{
	memset(depth,0x3f3f,sizeof(depth));
	depth[0]=0;
	depth[1]=1;
	queue<int> q;
	q.push(1);
	while(q.size())
	{
		
		int t=q.front();
		q.pop();
		for(auto& e:edge1[t])
		{
			int j=e.first;
			if(depth[j]>depth[t]+1)
			{
				depth[j]=depth[t]+1;
				q.push(j);
				fa[j][0]=t;
				d1[j][0]=e.second,d2[j][0]=-0x3f3f3f3f;
				for(int k=1;k<=16;k++)
				{
					int anc=fa[j][k-1];
					fa[j][k]=fa[fa[j][k-1]][k-1];
					int distance[4]={d1[j][k-1],d2[j][k-1],d1[anc][k-1],d2[anc][k-1]};
					d1[j][k]=d2[j][k]=-0x3f3f3f3f;
					for(int z=0;z<4;z++)
					{
						int d=distance[z];
						if(d>d1[j][k])
							d2[j][k]=d1[j][k],d1[j][k]=d;
						else if(d!=d1[j][k] && d>d2[j][k])
							d2[j][k]=d;
						
					}
				}
			}
		}
	}
}
int lca(int x,int y,int w)
{
	static int distance[N*2];
	int cnt=0;
	if(depth[x]<depth[y])
		swap(x,y);
	for(int k=16;k>=0;k--)
	{
		if(depth[fa[x][k]]>=depth[y])
		{
			distance[cnt++]=d1[x][k];
			distance[cnt++]=d2[x][k];
			x=fa[x][k];			
		}
	}
	if(x!=y)
	{
		for(int k=16;k>=0;k--)
		{
			if(fa[x][k]!=fa[y][k])
			{
				distance[cnt++]=d1[x][k];
				distance[cnt++]=d2[x][k];
				distance[cnt++]=d1[y][k];
				distance[cnt++]=d2[y][k];
				x=fa[x][k];
				y=fa[y][k];
			}
		}
		distance[cnt++]=d1[x][0];
		distance[cnt++]=d1[y][0];
	}
	int dist1=-0x3f3f3f3f,dist2=-0x3f3f3f3f;
	for(int i=0;i<cnt;i++)
	{
		int d=distance[i];
		if(d>dist1)
			dist2=dist1,dist1=d;
		else if(d!=dist1 && d>dist2)
			dist2=d;
	}
	if(w>dist1) return w-dist1;
	if(w>dist2) return w-dist2;
	return 0x3f3f3f3f;
}
int main()
{
	cin>>n>>m;
	
		
	for(int i=0;i<m;i++)
	{
		scanf("%d%d%d",&edge[i].a,&edge[i].b,&edge[i].w);	
	}
	
	ll sum=kluscal();
	build();
	bfs();
	ll ret=1e18;
	for(int i=0;i<m;i++)
	{
		if(!edge[i].used)
		{
			int x=edge[i].a,y=edge[i].b,w=edge[i].w;
			ret=min(ret,sum+lca(x,y,w));
		}
	}
	cout<<ret<<endl;
	return 0;
}
